home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / Python 1.1 / Python / import.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-26  |  17.4 KB  |  795 lines  |  [TEXT/KAHL]
  1. /***********************************************************
  2. Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
  3. Amsterdam, The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* Module definition and import implementation */
  26.  
  27. #include "allobjects.h"
  28.  
  29. #include "node.h"
  30. #include "token.h"
  31. #include "graminit.h"
  32. #include "import.h"
  33. #include "errcode.h"
  34. #include "sysmodule.h"
  35. #include "pythonrun.h"
  36. #include "marshal.h"
  37. #include "compile.h"
  38. #include "eval.h"
  39. #include "osdefs.h"
  40.  
  41. extern int verbose; /* Defined in pythonrun.c */
  42.  
  43. extern long getmtime(); /* In getmtime.c */
  44.  
  45. #ifdef DEBUG
  46. #define D(x) x
  47. #else
  48. #define D(x)
  49. #endif
  50.  
  51. /* Explanation of some of the the various #defines used by dynamic linking...
  52.  
  53.    symbol    -- defined for:
  54.  
  55.    DYNAMIC_LINK -- any kind of dynamic linking
  56.    USE_RLD    -- NeXT dynamic linking
  57.    USE_DL    -- Jack's dl for IRIX 4 or GNU dld with emulation for Jack's dl
  58.    USE_SHLIB    -- SunOS or IRIX 5 (SVR4?) shared libraries
  59.    _AIX        -- AIX style dynamic linking
  60.    NT        -- NT style dynamic linking (using DLLs)
  61.    _DL_FUNCPTR_DEFINED    -- if the typedef dl_funcptr has been defined
  62.    WITH_MAC_DL    -- Mac dynamic linking (highly experimental)
  63.    SHORT_EXT    -- short extension for dynamic module, e.g. ".so"
  64.    LONG_EXT    -- long extension, e.g. "module.so"
  65.    hpux        -- HP-UX Dynamic Linking - defined by the compiler
  66.  
  67.    (The other WITH_* symbols are used only once, to set the
  68.    appropriate symbols.)
  69. */
  70.  
  71. /* Configure dynamic linking */
  72.  
  73. #ifdef hpux
  74. #define DYNAMIC_LINK
  75. #include <errno.h>
  76. typedef void (*dl_funcptr)();
  77. #define _DL_FUNCPTR_DEFINED 1
  78. #define SHORT_EXT ".sl"
  79. #define LONG_EXT "module.sl"
  80. #endif 
  81.  
  82. #ifdef NT
  83. #define DYNAMIC_LINK
  84. #include <windows.h>
  85. typedef FARPROC dl_funcptr;
  86. #define _DL_FUNCPTR_DEFINED
  87. #define SHORT_EXT ".dll"
  88. #define LONG_EXT "module.dll"
  89. #endif
  90.  
  91. #if defined(NeXT) || defined(WITH_RLD)
  92. #define DYNAMIC_LINK
  93. #define USE_RLD
  94. #endif
  95.  
  96. #ifdef WITH_SGI_DL
  97. #define DYNAMIC_LINK
  98. #define USE_DL
  99. #endif
  100.  
  101. #ifdef WITH_DL_DLD
  102. #define DYNAMIC_LINK
  103. #define USE_DL
  104. #endif
  105.  
  106. #ifdef WITH_MAC_DL
  107. #define DYNAMIC_LINK
  108. #endif
  109.  
  110. #if !defined(DYNAMIC_LINK) && defined(HAVE_DLFCN_H) && defined(HAVE_DLOPEN)
  111. #define DYNAMIC_LINK
  112. #define USE_SHLIB
  113. #endif
  114.  
  115. #ifdef _AIX
  116. #define DYNAMIC_LINK
  117. #include <sys/ldr.h>
  118. typedef void (*dl_funcptr)();
  119. #define _DL_FUNCPTR_DEFINED
  120. static void aix_loaderror(char *name);
  121. #endif
  122.  
  123. #ifdef DYNAMIC_LINK
  124.  
  125. #ifdef USE_SHLIB
  126. #include <dlfcn.h>
  127. #ifndef _DL_FUNCPTR_DEFINED
  128. typedef void (*dl_funcptr)();
  129. #endif
  130. #ifndef RTLD_LAZY
  131. #define RTLD_LAZY 1
  132. #endif
  133. #define SHORT_EXT ".so"
  134. #define LONG_EXT "module.so"
  135. #endif /* USE_SHLIB */
  136.  
  137. #if defined(USE_DL) || defined(hpux)
  138. #include "dl.h"
  139. #endif
  140.  
  141. #ifdef WITH_MAC_DL
  142. #include "dynamic_load.h"
  143. #endif
  144.  
  145. #ifdef USE_RLD
  146. #include <mach-o/rld.h>
  147. #define FUNCNAME_PATTERN "_init%s"
  148. #ifndef _DL_FUNCPTR_DEFINED
  149. typedef void (*dl_funcptr)();
  150. #endif
  151. #endif /* USE_RLD */
  152.  
  153. extern char *getprogramname();
  154.  
  155. #ifndef FUNCNAME_PATTERN
  156. #if defined(__hp9000s300)
  157. #define FUNCNAME_PATTERN "_init%s"
  158. #else
  159. #define FUNCNAME_PATTERN "init%s"
  160. #endif
  161. #endif
  162.  
  163. #if !defined(SHORT_EXT) && !defined(LONG_EXT)
  164. #define SHORT_EXT ".o"
  165. #define LONG_EXT "module.o"
  166. #endif /* !SHORT_EXT && !LONG_EXT */
  167.  
  168. #endif /* DYNAMIC_LINK */
  169.  
  170. /* Max length of module suffix searched for -- accommodates "module.so" */
  171. #ifndef MAXSUFFIXSIZE
  172. #define MAXSUFFIXSIZE 10
  173. #endif
  174.  
  175. /* Magic word to reject .pyc files generated by other Python versions */
  176. #define MAGIC 0x999903L /* Increment by one for each incompatible change */
  177.  
  178. static object *modules;
  179.  
  180. /* Forward */
  181. static int init_builtin PROTO((char *));
  182.  
  183. /* Helper for reading .pyc files */
  184.  
  185. long
  186. get_pyc_magic()
  187. {
  188.     return MAGIC;
  189. }
  190.  
  191. /* Initialization */
  192.  
  193. void
  194. initimport()
  195. {
  196.     if ((modules = newdictobject()) == NULL)
  197.         fatal("no mem for dictionary of modules");
  198. }
  199.  
  200. object *
  201. get_modules()
  202. {
  203.     return modules;
  204. }
  205.  
  206. object *
  207. add_module(name)
  208.     char *name;
  209. {
  210.     object *m;
  211.     if ((m = dictlookup(modules, name)) != NULL && is_moduleobject(m))
  212.         return m;
  213.     m = newmoduleobject(name);
  214.     if (m == NULL)
  215.         return NULL;
  216.     if (dictinsert(modules, name, m) != 0) {
  217.         DECREF(m);
  218.         return NULL;
  219.     }
  220.     DECREF(m); /* Yes, it still exists, in modules! */
  221.     return m;
  222. }
  223.  
  224. enum filetype {SEARCH_ERROR, PY_SOURCE, PY_COMPILED, C_EXTENSION};
  225.  
  226. static struct filedescr {
  227.     char *suffix;
  228.     char *mode;
  229.     enum filetype type;
  230. } filetab[] = {
  231. #ifdef DYNAMIC_LINK
  232. #ifdef SHORT_EXT
  233.     {SHORT_EXT, "rb", C_EXTENSION},
  234. #endif /* !SHORT_EXT */
  235. #ifdef LONG_EXT
  236.     {LONG_EXT, "rb", C_EXTENSION},
  237. #endif /* !LONG_EXT */
  238. #endif /* DYNAMIC_LINK */
  239.     {".py", "r", PY_SOURCE},
  240.     {".pyc", "rb", PY_COMPILED},
  241.     {0, 0}
  242. };
  243.  
  244. #ifdef DYNAMIC_LINK
  245. static object *
  246. load_dynamic_module(name, namebuf, m, m_ret)
  247.     char *name;
  248.     char *namebuf;
  249.     object *m;
  250.     object **m_ret;
  251. {
  252.     char funcname[258];
  253.     dl_funcptr p = NULL;
  254.     if (m != NULL) {
  255.         err_setstr(ImportError,
  256.                "cannot reload dynamically loaded module");
  257.         return NULL;
  258.     }
  259.     sprintf(funcname, FUNCNAME_PATTERN, name);
  260. #ifdef WITH_MAC_DL
  261.     {
  262.         object *v = dynamic_load(namebuf);
  263.         if (v == NULL)
  264.             return NULL;
  265.     }
  266. #else /* !WITH_MAC_DL */
  267. #ifdef USE_SHLIB
  268.     {
  269. #ifdef RTLD_NOW
  270.         /* RTLD_NOW: resolve externals now
  271.            (i.e. core dump now if some are missing) */
  272.         void *handle = dlopen(namebuf, RTLD_NOW);
  273. #else
  274.         void *handle;
  275.         if (verbose)
  276.             printf("dlopen(\"%s\", %d);\n", namebuf, RTLD_LAZY);
  277.         handle = dlopen(namebuf, RTLD_LAZY);
  278. #endif /* RTLD_NOW */
  279.         if (handle == NULL) {
  280.             err_setstr(ImportError, dlerror());
  281.             return NULL;
  282.         }
  283.         p = (dl_funcptr) dlsym(handle, funcname);
  284.     }
  285. #endif /* USE_SHLIB */
  286. #ifdef _AIX
  287.     p = (dl_funcptr) load(namebuf, 1, 0);
  288.     if (p == NULL) {
  289.         aix_loaderror(namebuf);
  290.         return NULL;
  291.     }
  292. #endif /* _AIX */
  293. #ifdef NT
  294.     {
  295.         HINSTANCE hDLL;
  296.         hDLL = LoadLibrary(namebuf);
  297.         if (hDLL==NULL){
  298.             char errBuf[64];
  299.             sprintf(errBuf, "DLL load failed with error code %d",
  300.                 GetLastError());
  301.             err_setstr(ImportError, errBuf);
  302.         return NULL;
  303.         }
  304.         p = GetProcAddress(hDLL, funcname);
  305.     }
  306. #endif /* NT */
  307. #ifdef USE_DL
  308.     p =  dl_loadmod(getprogramname(), namebuf, funcname);
  309. #endif /* USE_DL */
  310. #ifdef USE_RLD
  311.     {
  312.         NXStream *errorStream;
  313.         struct mach_header *new_header;
  314.         const char *filenames[2];
  315.         long ret;
  316.         unsigned long ptr;
  317.  
  318.         errorStream = NXOpenMemory(NULL, 0, NX_WRITEONLY);
  319.         filenames[0] = namebuf;
  320.         filenames[1] = NULL;
  321.         ret = rld_load(errorStream, &new_header, 
  322.                 filenames, NULL);
  323.  
  324.         /* extract the error messages for the exception */
  325.         if(!ret) {
  326.             char *streamBuf;
  327.             int len, maxLen;
  328.  
  329.             NXPutc(errorStream, (char)0);
  330.  
  331.             NXGetMemoryBuffer(errorStream,
  332.                 &streamBuf, &len, &maxLen);
  333.             err_setstr(ImportError, streamBuf);
  334.         }
  335.  
  336.         if(ret && rld_lookup(errorStream, funcname, &ptr))
  337.             p = (dl_funcptr) ptr;
  338.  
  339.         NXCloseMemory(errorStream, NX_FREEBUFFER);
  340.  
  341.         if(!ret)
  342.             return NULL;
  343.     }
  344. #endif /* USE_RLD */
  345. #ifdef hpux
  346.     {
  347.         shl_t lib;
  348.         int flags;
  349.  
  350.         flags = BIND_DEFERRED;
  351.         if (verbose)
  352.                 {
  353.                         flags = BIND_IMMEDIATE | BIND_NONFATAL | BIND_VERBOSE;
  354.                         printf("shl_load %s\n",namebuf);
  355.                 }
  356.                 lib = shl_load(namebuf, flags, 0);
  357.                 if (lib == NULL)
  358.                 {
  359.                         char buf[256];
  360.                         if (verbose)
  361.                                 perror(namebuf);
  362.                         sprintf(buf, "Failed to load %.200s", namebuf);
  363.                         err_setstr(ImportError, buf);
  364.                         return NULL;
  365.                 }
  366.                 if (verbose)
  367.                         printf("shl_findsym %s\n", funcname);
  368.                 shl_findsym(&lib, funcname, TYPE_UNDEFINED, (void *) &p);
  369.                 if (p == NULL && verbose)
  370.                         perror(funcname);
  371.     }
  372. #endif hpux
  373.     if (p == NULL) {
  374.         err_setstr(ImportError,
  375.            "dynamic module does not define init function");
  376.         return NULL;
  377.     }
  378.     (*p)();
  379.  
  380. #endif /* !WITH_MAC_DL */
  381.     *m_ret = m = dictlookup(modules, name);
  382.     if (m == NULL) {
  383.         if (err_occurred() == NULL)
  384.             err_setstr(SystemError,
  385.                    "dynamic module not initialized properly");
  386.         return NULL;
  387.     }
  388.     if (verbose)
  389.         fprintf(stderr,
  390.             "import %s # dynamically loaded from %s\n",
  391.             name, namebuf);
  392.     INCREF(None);
  393.     return None;
  394. }
  395. #endif /* DYNAMIC_LINK */
  396.  
  397. static object *
  398. get_module(m, name, m_ret)
  399.     /*module*/object *m;
  400.     char *name;
  401.     object **m_ret;
  402. {
  403.     int err, npath, i, len, namelen;
  404.     long magic;
  405.     long mtime, pyc_mtime;
  406.     char namebuf[MAXPATHLEN+1];
  407.     struct filedescr *fdp;
  408.     FILE *fp = NULL, *fpc = NULL;
  409.     node *n = NULL;
  410.     object *path, *v, *d;
  411.     codeobject *co = NULL;
  412.  
  413.     path = sysget("path");
  414.     if (path == NULL || !is_listobject(path)) {
  415.         err_setstr(ImportError,
  416.                "sys.path must be list of directory names");
  417.         return NULL;
  418.     }
  419.     npath = getlistsize(path);
  420.     namelen = strlen(name);
  421.     for (i = 0; i < npath; i++) {
  422.         v = getlistitem(path, i);
  423.         if (!is_stringobject(v))
  424.             continue;
  425.         len = getstringsize(v);
  426.         if (len + 1 + namelen + MAXSUFFIXSIZE >= MAXPATHLEN)
  427.             continue; /* Too long */
  428.         strcpy(namebuf, getstringvalue(v));
  429.         if (strlen(namebuf) != len)
  430.             continue; /* v contains '\0' */
  431.         if (len > 0 && namebuf[len-1] != SEP)
  432.             namebuf[len++] = SEP;
  433.         strcpy(namebuf+len, name);
  434.         len += namelen;
  435.         for (fdp = filetab; fdp->suffix != NULL; fdp++) {
  436.             strcpy(namebuf+len, fdp->suffix);
  437.             if (verbose > 1)
  438.                 fprintf(stderr, "# trying %s\n", namebuf);
  439.             fp = fopen(namebuf, fdp->mode);
  440.             if (fp != NULL)
  441.                 break;
  442.         }
  443.         if (fp != NULL)
  444.             break;
  445.     }
  446.     if (fp == NULL) {
  447.         sprintf(namebuf, "No module named %.200s", name);
  448.         err_setstr(ImportError, namebuf);
  449.         return NULL;
  450.     }
  451.  
  452.     switch (fdp->type) {
  453.  
  454.     case PY_SOURCE:
  455.         mtime = getmtime(namebuf);
  456.         len = strlen(namebuf);
  457.         strcpy(namebuf + len, "c");
  458.         fpc = fopen(namebuf, "rb");
  459.         if (fpc != NULL) {
  460.             magic = rd_long(fpc);
  461.             if (magic != MAGIC) {
  462.                 if (verbose)
  463.                     fprintf(stderr,
  464.                         "# %s has bad magic\n",
  465.                         namebuf);
  466.             }
  467.             else {
  468.                 pyc_mtime = rd_long(fpc);
  469.                 if (pyc_mtime != mtime) {
  470.                     if (verbose)
  471.                         fprintf(stderr,
  472.                           "# %s has bad mtime\n",
  473.                           namebuf);
  474.                 }
  475.                 else {
  476.                     fclose(fp);
  477.                     fp = fpc;
  478.                     if (verbose)
  479.                        fprintf(stderr,
  480.                          "# %s matches %s.py\n",
  481.                            namebuf, name);
  482.                     goto use_compiled;
  483.                 }
  484.             }
  485.             fclose(fpc);
  486.         }
  487.         namebuf[len] = '\0';
  488.         n = parse_file(fp, namebuf, file_input);
  489.         fclose(fp);
  490.         if (n == NULL)
  491.             return NULL;
  492.         co = compile(n, namebuf);
  493.         freetree(n);
  494.         if (co == NULL)
  495.             return NULL;
  496.         if (verbose)
  497.             fprintf(stderr,
  498.                 "import %s # from %s\n", name, namebuf);
  499.         /* Now write the code object to the ".pyc" file */
  500.         strcpy(namebuf + len, "c");
  501.         fpc = fopen(namebuf, "wb");
  502. #ifdef macintosh
  503.         setfiletype(namebuf, 'PYTH', 'PYC ');
  504. #endif
  505.         if (fpc == NULL) {
  506.             if (verbose)
  507.                 fprintf(stderr,
  508.                     "# can't create %s\n", namebuf);
  509.         }
  510.         else {
  511.             wr_long(MAGIC, fpc);
  512.             /* First write a 0 for mtime */
  513.             wr_long(0L, fpc);
  514.             wr_object((object *)co, fpc);
  515.             if (ferror(fpc)) {
  516.                 if (verbose)
  517.                     fprintf(stderr,
  518.                         "# can't write %s\n", namebuf);
  519.                 /* Don't keep partial file */
  520.                 fclose(fpc);
  521.                 (void) unlink(namebuf);
  522.             }
  523.             else {
  524.                 /* Now write the true mtime */
  525.                 fseek(fpc, 4L, 0);
  526.                 wr_long(mtime, fpc);
  527.                 fflush(fpc);
  528.                 fclose(fpc);
  529.                 if (verbose)
  530.                     fprintf(stderr,
  531.                         "# wrote %s\n", namebuf);
  532.             }
  533.         }
  534.         break;
  535.  
  536.     case PY_COMPILED:
  537.         if (verbose)
  538.             fprintf(stderr, "# %s without %s.py\n",
  539.                 namebuf, name);
  540.         magic = rd_long(fp);
  541.         if (magic != MAGIC) {
  542.             err_setstr(ImportError,
  543.                    "Bad magic number in .pyc file");
  544.             return NULL;
  545.         }
  546.         (void) rd_long(fp);
  547.     use_compiled:
  548.         v = rd_object(fp);
  549.         fclose(fp);
  550.         if (v == NULL || !is_codeobject(v)) {
  551.             XDECREF(v);
  552.             err_setstr(ImportError,
  553.                    "Bad code object in .pyc file");
  554.             return NULL;
  555.         }
  556.         co = (codeobject *)v;
  557.         if (verbose)
  558.             fprintf(stderr,
  559.                 "import %s # precompiled from %s\n",
  560.                 name, namebuf);
  561.         break;
  562.  
  563. #ifdef DYNAMIC_LINK
  564.     case C_EXTENSION:
  565.         fclose(fp);
  566.         return load_dynamic_module(name, namebuf, m, m_ret);
  567. #endif /* DYNAMIC_LINK */
  568.  
  569.     default:
  570.         fclose(fp);
  571.         err_setstr(SystemError,
  572.                "search loop returned unexpected result");
  573.         return NULL;
  574.  
  575.     }
  576.  
  577.     /* We get here for either PY_SOURCE or PY_COMPILED */
  578.     if (m == NULL) {
  579.         m = add_module(name);
  580.         if (m == NULL) {
  581.             freetree(n);
  582.             return NULL;
  583.         }
  584.         *m_ret = m;
  585.     }
  586.     d = getmoduledict(m);
  587.     v = eval_code(co, d, d, d, (object *)NULL);
  588.     DECREF(co);
  589.     return v;
  590. }
  591.  
  592. static object *
  593. load_module(name)
  594.     char *name;
  595. {
  596.     object *m, *v;
  597.     v = get_module((object *)NULL, name, &m);
  598.     if (v == NULL)
  599.         return NULL;
  600.     DECREF(v);
  601.     return m;
  602. }
  603.  
  604. object *
  605. import_module(name)
  606.     char *name;
  607. {
  608.     object *m;
  609.     int n;
  610.     if ((m = dictlookup(modules, name)) == NULL) {
  611.         if ((n = init_builtin(name)) || (n = init_frozen(name))) {
  612.             if (n < 0)
  613.                 return NULL;
  614.             if ((m = dictlookup(modules, name)) == NULL) {
  615.                 if (err_occurred() == NULL)
  616.                     err_setstr(SystemError,
  617.                    "builtin module not initialized properly");
  618.             }
  619.         }
  620.         else {
  621.             m = load_module(name);
  622.         }
  623.     }
  624.     return m;
  625. }
  626.  
  627. object *
  628. reload_module(m)
  629.     object *m;
  630. {
  631.     char *name;
  632.     int i;
  633.     if (m == NULL || !is_moduleobject(m)) {
  634.         err_setstr(TypeError, "reload() argument must be module");
  635.         return NULL;
  636.     }
  637.     name = getmodulename(m);
  638.     if (name == NULL)
  639.         return NULL;
  640.     /* Check for built-in modules */
  641.     for (i = 0; inittab[i].name != NULL; i++) {
  642.         if (strcmp(name, inittab[i].name) == 0) {
  643.             err_setstr(ImportError,
  644.                    "cannot reload built-in module");
  645.             return NULL;
  646.         }
  647.     }
  648.     /* Check for frozen modules */
  649.     if ((i = init_frozen(name)) != 0) {
  650.         if (i < 0)
  651.             return NULL;
  652.         INCREF(None);
  653.         return None;
  654.     }
  655.     return get_module(m, name, (object **)NULL);
  656. }
  657.  
  658. void
  659. doneimport()
  660. {
  661.     if (modules != NULL) {
  662.         int pos;
  663.         object *modname, *module;
  664.         /* Explicitly erase all modules; this is the safest way
  665.            to get rid of at least *some* circular dependencies */
  666.         pos = 0;
  667.         while (mappinggetnext(modules, &pos, &modname, &module)) {
  668.             if (is_moduleobject(module)) {
  669.                 object *dict;
  670.                 dict = getmoduledict(module);
  671.                 if (dict != NULL && is_dictobject(dict))
  672.                     mappingclear(dict);
  673.             }
  674.         }
  675.         mappingclear(modules);
  676.     }
  677.     DECREF(modules);
  678.     modules = NULL;
  679. }
  680.  
  681.  
  682. /* Initialize built-in modules when first imported */
  683.  
  684. static int
  685. init_builtin(name)
  686.     char *name;
  687. {
  688.     int i;
  689.     for (i = 0; inittab[i].name != NULL; i++) {
  690.         if (strcmp(name, inittab[i].name) == 0) {
  691.             if (inittab[i].initfunc == NULL) {
  692.                 err_setstr(ImportError,
  693.                        "cannot re-init internal module");
  694.                 return -1;
  695.             }
  696.             if (verbose)
  697.                 fprintf(stderr, "import %s # builtin\n",
  698.                     name);
  699.             (*inittab[i].initfunc)();
  700.             return 1;
  701.         }
  702.     }
  703.     return 0;
  704. }
  705.  
  706. extern struct frozen {
  707.     char *name;
  708.     char *code;
  709.     int size;
  710. } frozen_modules[];
  711.  
  712. int
  713. init_frozen(name)
  714.     char *name;
  715. {
  716.     struct frozen *p;
  717.     codeobject *co;
  718.     object *m, *d, *v;
  719.     for (p = frozen_modules; ; p++) {
  720.         if (p->name == NULL)
  721.             return 0;
  722.         if (strcmp(p->name, name) == 0)
  723.             break;
  724.     }
  725.     if (verbose)
  726.         fprintf(stderr, "import %s # frozen\n", name);
  727.     co = (codeobject *) rds_object(p->code, p->size);
  728.     if (co == NULL)
  729.         return -1;
  730.     if ((m = add_module(name)) == NULL ||
  731.         (d = getmoduledict(m)) == NULL ||
  732.         (v = eval_code(co, d, d, d, (object*)NULL)) == NULL) {
  733.         DECREF(co);
  734.         return -1;
  735.     }
  736.     DECREF(co);
  737.     DECREF(v);
  738.     return 1;
  739. }
  740.  
  741.  
  742. #ifdef _AIX
  743.  
  744. #include <ctype.h>    /* for isdigit()    */
  745. #include <errno.h>    /* for global errno    */
  746. #include <string.h>    /* for strerror()    */
  747.  
  748. void aix_loaderror(char *namebuf)
  749. {
  750.  
  751.     char *message[8], errbuf[1024];
  752.     int i,j;
  753.  
  754.     struct errtab { 
  755.         int errno;
  756.         char *errstr;
  757.     } load_errtab[] = {
  758.         {L_ERROR_TOOMANY,    "to many errors, rest skipped."},
  759.         {L_ERROR_NOLIB,        "can't load library:"},
  760.         {L_ERROR_UNDEF,        "can't find symbol in library:"},
  761.         {L_ERROR_RLDBAD,
  762.          "RLD index out of range or bad relocation type:"},
  763.         {L_ERROR_FORMAT,    "not a valid, executable xcoff file:"},
  764.         {L_ERROR_MEMBER,
  765.          "file not an archive or does not contain requested member:"},
  766.         {L_ERROR_TYPE,        "symbol table mismatch:"},
  767.         {L_ERROR_ALIGN,        "text allignment in file is wrong."},
  768.         {L_ERROR_SYSTEM,    "System error:"},
  769.         {L_ERROR_ERRNO,        NULL}
  770.     };
  771.  
  772. #define LOAD_ERRTAB_LEN    (sizeof(load_errtab)/sizeof(load_errtab[0]))
  773. #define ERRBUF_APPEND(s) strncat(errbuf, s, sizeof(errbuf)-strlen(errbuf)-1)
  774.  
  775.     sprintf(errbuf, " from module %.200s ", namebuf);
  776.  
  777.     if (!loadquery(1, &message[0], sizeof(message))) 
  778.         ERRBUF_APPEND(strerror(errno));
  779.     for(i = 0; message[i] && *message[i]; i++) {
  780.         int nerr = atoi(message[i]);
  781.         for (j=0; j<LOAD_ERRTAB_LEN ; j++) {
  782.             if (nerr == load_errtab[i].errno && load_errtab[i].errstr)
  783.             ERRBUF_APPEND(load_errtab[i].errstr);
  784.         }
  785.         while (isdigit(*message[i])) message[i]++ ; 
  786.         ERRBUF_APPEND(message[i]);
  787.         ERRBUF_APPEND("\n");
  788.     }
  789.     errbuf[strlen(errbuf)-1] = '\0';    /* trim off last newline */
  790.     err_setstr(ImportError, errbuf); 
  791.     return; 
  792. }
  793.  
  794. #endif /* _AIX */
  795.